//! 区块链核心模块，负责链的创建、区块添加和验证等核心逻辑

use std::collections::HashMap;
use crate::block::Block;
use crate::pow::ProofOfWork;
use crate::transaction::Transaction;
use crate::smart_contract::SmartContract;
use chrono::Utc;

/// 区块链数据结构
#[derive(Debug, Clone)]
#[allow(dead_code)] // TODO: 待实现的智能合约功能
pub struct Blockchain {
    /// 区块的链式存储（内存中完整链）
    chain: Vec<Block>,
    /// 工作量证明算法实例
    pow: ProofOfWork,
    /// 区块哈希快速查询表（模拟UTXO模型）
    block_map: HashMap<String, Block>,
    /// 智能合约执行器（预留功能）
    smart_contract: SmartContract,
    /// 交易池（等待打包的交易）
    pending_transactions: Vec<Transaction>,
}

impl Blockchain {
    /// 初始化新区块链
    /// # 参数
    /// - difficulty: 工作量证明难度（前导零数量）
    pub fn new(difficulty: usize) -> Self {
        // 初始化工作量证明算法
        let pow = ProofOfWork::new(difficulty);
        // 生成创世区块
        let genesis_block = Block::genesis();
        // 对创世区块进行挖矿计算
        let mined_block = pow.mine_block(genesis_block);

        // 构建初始区块映射
        let mut block_map = HashMap::new();
        block_map.insert(mined_block.hash.clone(), mined_block.clone());

        Blockchain {
            chain: vec![mined_block],
            pow,
            block_map,
            smart_contract: SmartContract, // 预留智能合约实例
            pending_transactions: Vec::new(),
        }
    }

    /// 添加新区块到链上
    /// # 参数
    /// - miner_address: 矿工奖励接收地址
    pub fn add_block(&mut self, miner_address: &str) {
        // 获取上一个区块作为父区块
        let previous_block = self.chain.last().expect("Chain should have genesis block");
        
        // 取出待处理交易并进行签名验证
        let mut transactions = std::mem::take(&mut self.pending_transactions)
            .into_iter()
            .filter(|tx| tx.verify())
            .collect::<Vec<_>>();

        // 添加矿工奖励交易（固定50个代币）
        transactions.push(Transaction::new(
            "0".to_string(),          // 系统账户
            miner_address.to_string(),// 矿工地址
            50                        // 奖励金额
        ));

        // 构建新区块
        let new_block = Block::new(
            previous_block.index + 1, // 区块高度递增
            Utc::now().timestamp(),   // 当前时间戳
            transactions,             // 包含的交易
            previous_block.hash.clone(), // 父区块哈希
            0,                        // 初始nonce值
        );

        // 执行工作量证明计算
        let mined_block = self.pow.mine_block(new_block);
        // 更新区块映射
        self.block_map.insert(mined_block.hash.clone(), mined_block.clone());
        // 将新区块加入链
        self.chain.push(mined_block);
    }

    /// 验证区块链完整性
    /// 返回 bool 表示是否有效
    pub fn is_valid(&self) -> bool {
        // 空链无效
        if self.chain.is_empty() {
            return false;
        }

        // 验证创世区块规则
        let genesis = &self.chain[0];
        if genesis.index != 0 ||          // 高度必须为0
           genesis.previous_hash != "0" || // 前哈希必须为"0"
           !genesis.transactions.is_empty() // 必须无交易
        {
            return false;
        }

        // 遍历验证每个区块
        for i in 1..self.chain.len() {
            let current = &self.chain[i];
            let prev = &self.chain[i - 1];
            
            // 验证当前区块哈希计算正确
            // 验证父哈希链接正确
            // 验证工作量证明有效性
            if current.hash != current.calculate_hash() ||
               current.previous_hash != prev.hash ||
               !self.pow.is_valid(current)
            {
                return false;
            }
        }
        true
    }

    // 其他方法...

    pub fn chain(&self) -> &[Block] {
        &self.chain
    }

    pub fn chain_mut(&mut self) -> &mut Vec<Block> {
        &mut self.chain
    }

    pub fn add_transaction(&mut self, tx: Transaction) {
        self.pending_transactions.push(tx);
    }

    #[allow(dead_code)]  // 添加到方法前
    pub fn pending_transactions(&self) -> &[Transaction] {
        &self.pending_transactions
    }
}